#include "User.h"
#include <regex>

Seller::Seller(int id, UserController &userC)
{
    setId(id);
    setUsername(userC.findUsername(id));
    setBalance(userC.getBalanceById(id));   
    setPassword(userC.getPasswordById(id)); 
}

Customer::Customer(int id, UserController &userCtrl, ProductController &productCtrl)
{
    setId(id);
    setUsername(userCtrl.findUsername(id));
    setBalance(userCtrl.getBalanceById(id));   
    setPassword(userCtrl.getPasswordById(id)); 

    json userJson = userCtrl.getUserDataById(id); 

    // 3. 【新增】加载购物车
    if (userJson.contains("cart") && userJson["cart"].is_array())
    {
        shoppingCart.loadFromJson(userJson["cart"], productCtrl);
    }

    // 4. 【新增】加载未支付订单
    if (userJson.contains("unpaidOrders") && userJson["unpaidOrders"].is_array())
    {
        for (const auto &j_order : userJson["unpaidOrders"])
        {
            // 使用 Order 的新构造函数从 JSON 创建对象
            unpayedOrders.emplace_back(j_order);
        }
    }
}



UserController::UserController()
{
    openUserFile();
}
UserController::~UserController()
{
    saveUserData();
}

bool UserController::isPasswordValid(const string &PW) const
{
    std::regex pattern("^[a-zA-Z0-9]{5,12}$");
    return std::regex_match(PW, pattern);
}

bool UserController::isUsernameValid(const string &UN) const
{
    std::regex pattern("^[a-zA-Z0-9]{3,18}$");
    return std::regex_match(UN, pattern);
}

// 打开文件需要反实例化
void UserController::openUserFile()
{
    users = JsonHandler::loadFormFile(usersFile);
    for (const auto &user_obj : users)
    { // user_obj 在这里是 const json&
        // 首先检查所有必要的键是否存在
        if (user_obj.is_object() && // 确保 user_obj 本身是一个对象
            user_obj.contains("id") &&
            user_obj.contains("name") &&
            user_obj.contains("password") &&
            user_obj.contains("balance") &&
            user_obj.contains("usertype"))
        {
            // 检查完存在后，再检查类型并获取值
            if (user_obj["id"].is_number_integer() &&
                user_obj["name"].is_string() &&
                user_obj["password"].is_string() &&
                user_obj["balance"].is_number() &&
                user_obj["usertype"].is_string())
            {
                int id = user_obj["id"].get<int>();
                id_usernames[id] = user_obj["name"].get<std::string>();
                id_passwords[id] = user_obj["password"].get<std::string>();
                id_balance[id] = user_obj["balance"].get<double>();
                id_usertype[id] = user_obj["usertype"].get<std::string>();
                lastId = std::max(lastId, id);
            }
            else
            {
                // 处理数据类型不正确的情况
                std::cerr << "用户对象中存在字段，但数据类型不正确。ID (如果存在): ";
                if (user_obj.contains("id") && user_obj["id"].is_number_integer())
                {
                    std::cerr << user_obj["id"].get<int>();
                }
                else
                {
                    std::cerr << "未知或无效";
                }
                std::cerr << std::endl;
            }
        }
        else
        {
            // 处理缺少必要键的情况
            std::cerr << "从 users.json 加载的用户对象缺少必要的键 (id, name, password, balance, usertype) 或不是一个JSON对象。" << std::endl;
        }
    }
}

void UserController::saveUserData() const // 修改为 const
{
    // 现在这个函数只负责将内存中的 users json 数组写回文件
    JsonHandler::saveToFile(usersFile, users);
}

bool UserController::changePassword(const int &id, const string &newPW)
{
    // 首先检查用户是否存在
    if (id_passwords.count(id))
    { // 或者 id_usernames.count(id)
        if (isPasswordValid(newPW))
        {
            id_passwords[id] = newPW;
            cout << "密码修改成功！" << endl;
            for (auto &user_obj : users)
            {
                if (user_obj.is_object() && user_obj.contains("id") && user_obj["id"].get<int>() == id)
                {
                    user_obj["password"] = id_passwords[id];
                    break; // 找到并更新后即可退出循环
                }
            }
            saveUserData(); // 假设修改后保存
            return true;
        }
        else
        {
            cout << "密码格式错误！请设置密码为5-12位字母或数字。" << endl;
            return false; // 密码格式不正确
        }
    }
    else
    {
        cout << "用户ID " << id << " 不存在，无法修改密码。" << endl;
        return false; // 用户不存在
    }
}

bool UserController::isUserNameExist(const string &name) const
{
    for (const auto &user_info : id_usernames)
    {
        if (user_info.second == name)
            return true;
    }
    return false;
}

bool UserController::setUsername(const int &id, const string &newUN)
{
    if (id_usernames.count(id))
    {
        if (!isUsernameValid(newUN))
        {
            cout << "用户名格式错误！请设置用户名为3-18位字母或数字。" << endl;
            return false; // 用户名格式不正确
        }
        if (isUserNameExist(newUN))
        { // 检查新用户名是否已存在
            cout << "用户名已存在，请选择其他用户名。" << endl;
            return false; // 用户名已存在
        }
        id_usernames[id] = newUN;
        for (auto &user_obj : users)
        {
            if (user_obj.is_object() && user_obj.contains("id") && user_obj["id"].get<int>() == id)
            {
                user_obj["name"] = id_usernames[id];
                break; // 找到并更新后即可退出循环
            }
        }
        saveUserData(); // 保存用户数据到文件, 实时更新
        cout << "用户名设置成功！" << endl;
        return true; // 成功设置用户名
    }
    else
        cout << "用户ID " << id << " 不存在，无法修改用户名" << endl;
    return false; // 用户不存在
}

std::pair<int, string> UserController::toLogin(const string inputName, const string inputPassword) const
{
    for (const auto &user_info : id_usernames)
    {
        if (user_info.second == inputName)
        {
            auto itsPW = id_passwords.find(user_info.first);
            if (inputPassword == itsPW->second) // 密码匹配成功
            {
                auto it = id_usertype.find(user_info.first);
                cout << " ------ 登录成功！登录状态为: " << it->second << "。 ------ " << endl;
                return make_pair(user_info.first, it->second);
            }
            else
            {
                cout << " ------ 登录失败！用户名或密码不正确。------" << endl;
                return make_pair(-1, "unknown");
            }
        }
    }
    cout << " ------ 登录失败！用户不存在。------" << endl;
    return make_pair(-1, "unknown");
}

int UserController::toRegister(const string inputName, const string inputPassword, const string inputUsertype)
{

    id_usernames.insert(make_pair(++lastId, inputName));
    id_passwords.insert(make_pair(lastId, inputPassword));
    id_balance.insert(make_pair(lastId, 0.0));
    id_usertype.insert(make_pair(lastId, inputUsertype));
    saveUserData(); // 保存用户数据到文件, 实时更新
    cout << " ------ 注册成功！------" << endl;
    return lastId;
}

void UserController::displayAllUsersDebug() const
{
    std::cout << "\n--- 目前内存中的用户信息为 ---" << std::endl;
    if (id_usernames.empty())
    {
        std::cout << "无." << std::endl;
        return;
    }
    for (const auto &pair : id_usernames)
    {
        int id = pair.first;
        std::cout << "ID: " << id
                  << ", Name: " << pair.second
                  << ", PW: " << (id_passwords.count(id) ? id_passwords.at(id) : "N/A")
                  << ", Bal: " << (id_balance.count(id) ? id_balance.at(id) : -1.0)
                  << ", Type: " << (id_usertype.count(id) ? id_usertype.at(id) : "N/A")
                  << std::endl;
    }
    std::cout << "Last ID used: " << lastId << std::endl;
    std::cout << "-----------------------------" << std::endl;
}

json UserController::getUserDataById(int id) const
{
    for (const auto &user_obj : users)
    {
        if (user_obj.is_object() && user_obj.contains("id") && user_obj["id"].get<int>() == id)
        {
            return user_obj;
        }
    }
    return json::object(); // 返回一个空对象表示未找到
}

// 【新增】UserController::syncCustomerState
void UserController::syncCustomerState(const Customer &customer)
{
    for (auto &user_obj : users)
    { // 注意这里需要非 const 引用以便修改
        if (user_obj.is_object() && user_obj.contains("id") && user_obj["id"].get<int>() == customer.getId())
        {
            // 找到了对应的用户JSON对象，现在更新它

            // 更新购物车
            user_obj["cart"] = customer.getShoppingCart().toJson();

            // 更新未支付订单
            json j_unpaid_orders = json::array();
            for (const auto &order : customer.getUnpaidOrders())
            {
                j_unpaid_orders.push_back(order.toJson());
            }
            user_obj["unpaidOrders"] = j_unpaid_orders;

            // (可选)同时更新余额等其他可能变化的信息
            user_obj["balance"] = customer.getBalance();

            // 找到并更新后就可以退出了
            return;
        }
    }
}

json UserController::handleLogin(const std::string &username, const std::string &password)
{
    json response;
    auto loginResult = toLogin(username, password);
    if (loginResult.first != -1)
    {
        response["status"] = "SUCCESS";
        response["message"] = "Login successful.";
        response["data"] = getUserDataById(loginResult.first); // 返回用户完整数据
    }
    else
    {
        response["status"] = "ERROR";
        response["message"] = "Invalid username or password.";
    }
    return response;
}

json UserController::handleRegister(const std::string &username, const std::string &password, const std::string &userType)
{
    json response;
    if (isUserNameExist(username))
    {
        response["status"] = "ERROR";
        response["message"] = "Username already exists.";
        return response;
    }
    int newId = toRegister(username, password, userType);
    if (newId != -1)
    {
        response["status"] = "SUCCESS";
        response["message"] = "Registration successful.";
        response["data"]["userId"] = newId;
    }
    else
    {
        response["status"] = "ERROR";
        response["message"] = "Registration failed.";
    }
    return response;
}

json UserController::handleAddToCart(int userId, const std::string &productId, int quantity, ProductController &productCtrl)
{
    json response;
    Product *p = productCtrl.findProductById(productId);
    if (!p)
    {
        response["status"] = "ERROR";
        response["message"] = "未找到商品ID为 " + productId + " 的商品。";
        return response;
    }
    if (p->getAvailableQuantity() < quantity)
    {
        response["status"] = "ERROR";
        response["message"] = "库存不足。 该商品仅剩 " + std::to_string(p->getAvailableQuantity()) + " 件。";
        return response;
    }

    // 直接修改内存中的用户JSON数据
    for (auto &user_obj : users)
    {
        if (user_obj["id"].get<int>() == userId)
        {
            // 确保cart字段存在且为数组
            if (!user_obj.contains("cart") || !user_obj["cart"].is_array())
            {
                user_obj["cart"] = json::array();
            }
            // 检查商品是否已在购物车中
            bool found = false;
            for (auto &item : user_obj["cart"])
            {
                if (item["productId"] == productId)
                {
                    item["quantity"] = item["quantity"].get<int>() + quantity;
                    found = true;
                    break;
                }
            }
            if (!found)
            {
                user_obj["cart"].push_back({{"productId", productId}, {"quantity", quantity}});
            }
            saveUserData(); // 保存更改
            response["status"] = "SUCCESS";
            response["message"] = "商品已添加到购物车.";
            return response;
        }
    }

    response["status"] = "ERROR";
    response["message"] = "未找到用户.";
    return response;
}
json UserController::handleGetCart(int userId, ProductController &productCtrl)
{
    json response;
    json user_json = getUserDataById(userId);
    if (user_json.empty())
    {
        response["status"] = "ERROR";
        response["message"] = "未找到用户.";
        return response;
    }

    // 购物车数据是简单的 {productId, quantity} 列表
    json simple_cart = user_json.value("cart", json::array());
    json detailed_cart = json::array();
    double totalPrice = 0.0;

    // 将简单购物车转换为包含商品详情的完整购物车
    for (const auto &item : simple_cart)
    {
        std::string pid = item.value("productId", "");
        int qty = item.value("quantity", 0);
        if (pid.empty() || qty <= 0)
            continue;

        Product *p = productCtrl.findProductById(pid);
        if (p)
        {
            json detailed_item = p->toJson();      // 获取商品所有信息
            detailed_item["quantityInCart"] = qty; // 添加在购物车中的数量
            totalPrice += p->getPrice() * qty;
            detailed_cart.push_back(detailed_item);
        }
    }

    response["status"] = "SUCCESS";
    response["data"]["items"] = detailed_cart;
    response["data"]["totalPrice"] = totalPrice;
    return response;
}

json UserController::handleCreateOrder(int userId, ProductController &productCtrl)
{
    json response;
    json user_json = getUserDataById(userId);
    if (user_json.empty())
    {
        response["status"] = "ERROR";
        response["message"] = "User not found.";
        return response;
    }

    // 1. 创建一个临时的ShoppingCart对象来利用现有的检查逻辑
    ShoppingCart tempCart;
    tempCart.loadFromJson(user_json.value("cart", json::array()), productCtrl);

    if (tempCart.isEmpty())
    {
        response["status"] = "ERROR";
        response["message"] = "Cart is empty.";
        return response;
    }

    // 2. 使用Order的构造函数来检查库存并冻结商品
    Order order(userId, tempCart, productCtrl); // 这个构造函数包含核心逻辑

    // 3. 根据订单创建结果更新用户数据
    if (order.getStatus() == OrderStatus::UNPAID)
    {
        // 订单创建成功，更新用户的JSON数据
        for (auto &user_obj : users)
        {
            if (user_obj["id"].get<int>() == userId)
            {
                if (!user_obj.contains("unpaidOrders"))
                {
                    user_obj["unpaidOrders"] = json::array();
                }
                user_obj["unpaidOrders"].push_back(order.toJson()); // 添加新订单
                user_obj["cart"] = json::array();                   // 清空购物车
                break;
            }
        }
        saveUserData(); // 保存更改
        response["status"] = "SUCCESS";
        response["message"] = "Order created successfully.";
        response["data"] = order.toJson(); // 将新订单信息返回给客户端
    }
    else
    {
        // 订单创建失败
        response["status"] = "ERROR";
        response["message"] = "Failed to create order. " + orderStatusToString(order.getStatus());
    }
    return response;
}

json UserController::handlePayOrder(int userId, const std::string &orderId, ProductController &productCtrl)
{
    json response;
    bool orderFound = false;

    for (auto &user_obj : users)
    {
        if (user_obj["id"].get<int>() != userId)
            continue;

        if (!user_obj.contains("unpaidOrders") || !user_obj["unpaidOrders"].is_array())
        {
            break; // 用户没有未支付订单字段
        }

        auto &unpaid_orders_json = user_obj["unpaidOrders"];
        for (auto it = unpaid_orders_json.begin(); it != unpaid_orders_json.end(); ++it)
        {
            if ((*it)["orderId"].get<std::string>() == orderId)
            {
                orderFound = true;

                // 1. 从JSON重建Order和Customer对象以进行支付处理
                Order order_to_pay(*it);
                Customer customer(userId, *this, productCtrl); // 创建临时Customer对象

                // 2. 调用支付逻辑
                if (order_to_pay.processPayment(customer, *this, productCtrl))
                {
                    // 支付成功
                    // (可选) 将支付成功的订单移入 "paidOrders" 历史记录
                    // if (!user_obj.contains("paidOrders")) { user_obj["paidOrders"] = json::array(); }
                    // user_obj["paidOrders"].push_back(order_to_pay.toJson());

                    // 从未支付列表中移除
                    unpaid_orders_json.erase(it);
                    saveUserData();

                    response["status"] = "SUCCESS";
                    response["message"] = "Payment successful.";
                    response["data"]["orderId"] = orderId;
                }
                else
                {
                    // 支付失败
                    response["status"] = "ERROR";
                    response["message"] = "Payment failed. Reason: " + orderStatusToString(order_to_pay.getStatus());
                }
                return response; // 处理完毕，返回
            }
        }
    }

    if (!orderFound)
    {
        response["status"] = "ERROR";
        response["message"] = "Unpaid order with ID " + orderId + " not found.";
    }
    return response;
}

json UserController::handleUpdateCartItem(int userId, const std::string &productId, int newQuantity, ProductController &productCtrl)
{
    json response;
    for (auto &user_obj : users)
    {
        if (user_obj["id"].get<int>() != userId)
            continue;

        // 找到了用户
        if (!user_obj.contains("cart") || !user_obj["cart"].is_array())
        {
            response["status"] = "ERROR";
            response["message"] = "购物车为空或格式错误。";
            return response;
        }

        bool itemFound = false;
        auto &cart_array = user_obj["cart"];
        for (auto it = cart_array.begin(); it != cart_array.end(); ++it)
        {
            if ((*it)["productId"] == productId)
            {
                itemFound = true;
                if (newQuantity <= 0)
                {
                    // 数量小于等于0，移除商品
                    cart_array.erase(it);
                    response["message"] = "商品已从购物车移除。";
                }
                else
                {
                    // 检查库存是否充足
                    Product *p = productCtrl.findProductById(productId);
                    if (!p || p->getAvailableQuantity() < newQuantity)
                    {
                        response["status"] = "ERROR";
                        response["message"] = "库存不足，无法更新数量。";
                        return response;
                    }
                    (*it)["quantity"] = newQuantity;
                    response["message"] = "购物车商品数量已更新。";
                }
                saveUserData();
                response["status"] = "SUCCESS";
                return response;
            }
        }

        if (!itemFound)
        {
            response["status"] = "ERROR";
            response["message"] = "商品不在购物车中。";
        }
        return response;
    }

    response["status"] = "ERROR";
    response["message"] = "未找到用户。";
    return response;
}

json UserController::handleClearCart(int userId)
{
    json response;
    for (auto &user_obj : users)
    {
        if (user_obj["id"].get<int>() == userId)
        {
            // 直接将cart字段设置为空数组
            user_obj["cart"] = json::array();
            saveUserData();
            response["status"] = "SUCCESS";
            response["message"] = "购物车已清空。";
            return response;
        }
    }
    response["status"] = "ERROR";
    response["message"] = "未找到用户。";
    return response;
}

json UserController::handleRecharge(int userId, double amount)
{
    json response;
    if (amount <= 0)
    {
        response["status"] = "ERROR";
        response["message"] = "充值金额必须为正数。";
        return response;
    }

    for (auto &user_obj : users)
    {
        if (user_obj["id"].get<int>() == userId)
        {
            // 更新缓存的 map
            id_balance[userId] += amount;
            // 更新作为数据源的 JSON 对象
            user_obj["balance"] = id_balance[userId];

            saveUserData();
            response["status"] = "SUCCESS";
            response["message"] = "充值成功！";
            response["data"]["newBalance"] = id_balance[userId];
            return response;
        }
    }
    response["status"] = "ERROR";
    response["message"] = "未找到用户，充值失败。";
    return response;
}

json UserController::handleCancelOrder(int userId, const std::string &orderId, ProductController &productCtrl)
{
    json response;

    // 1. 遍历内存中的 users JSON 数组，找到对应的用户
    for (auto &user_obj : users)
    {
        if (user_obj["id"].get<int>() != userId)
            continue;

        // 找到了用户，现在查找其未支付订单
        if (!user_obj.contains("unpaidOrders") || !user_obj["unpaidOrders"].is_array())
        {
            response["status"] = "ERROR";
            response["message"] = "该用户没有任何未支付订单。";
            return response;
        }

        auto &unpaid_orders_json = user_obj["unpaidOrders"];
        // 2. 遍历用户的未支付订单数组
        for (auto it = unpaid_orders_json.begin(); it != unpaid_orders_json.end(); ++it)
        {
            if ((*it).is_object() && (*it).value("orderId", "") == orderId)
            {
                // 3. 找到了要取消的订单

                // 从JSON数据重新构造一个临时的Order对象，以便调用它的取消逻辑
                Order order_to_cancel(*it);

                // 4. 调用Order对象自己的cancelOrder方法，这个方法会负责解冻库存
                order_to_cancel.cancelOrder(productCtrl);
                // 注意: productCtrl->saveProducts() 应该在 order_to_cancel.cancelOrder() 内部被调用，以确保库存状态被保存

                // 5. 从用户的未支付订单列表中移除这个订单
                unpaid_orders_json.erase(it);

                // 6. 保存用户数据的变动
                saveUserData();

                response["status"] = "SUCCESS";
                response["message"] = "订单 " + orderId + " 已成功取消。";
                return response; // 成功处理后直接返回
            }
        }

        // 如果循环结束还没找到订单
        response["status"] = "ERROR";
        response["message"] = "未在您的未支付订单中找到ID为 " + orderId + " 的订单。";
        return response;
    }

    // 如果循环结束还没找到用户
    response["status"] = "ERROR";
    response["message"] = "未找到用户。";
    return response;
}
json UserController::handleGetUnpaidOrders(int userId)
{
    json response;
    json user_data = getUserDataById(userId);
    if (user_data.empty())
    {
        response["status"] = "ERROR";
        response["message"] = "未找到用户。";
        return response;
    }
    response["status"] = "SUCCESS";
    response["data"] = user_data.value("unpaidOrders", json::array());
    return response;
}